/**
 * 错误处理工具类
 * 用于统一处理各种错误，特别是权限相关错误
 */

class ErrorHandler {
  constructor() {
    this.permissionKeywords = [
      '权限',
      'permission',
      '摄像头',
      '录音',
      '存储',
      'camera',
      'microphone',
      'storage',
      'denied',
      'unauthorized'
    ]
  }

  /**
   * 判断是否为权限错误
   * @param {Error|String} error 错误对象或错误信息
   * @returns {Boolean} 是否为权限错误
   */
  isPermissionError(error) {
    const errorMessage = typeof error === 'string' ? error : (error.message || '')
    return this.permissionKeywords.some(keyword => 
      errorMessage.toLowerCase().includes(keyword.toLowerCase())
    )
  }

  /**
   * 判断是否为网络错误
   * @param {Error|String} error 错误对象或错误信息
   * @returns {Boolean} 是否为网络错误
   */
  isNetworkError(error) {
    const errorMessage = typeof error === 'string' ? error : (error.message || '')
    const networkKeywords = ['network', '网络', 'timeout', '超时', 'connection', '连接']
    return networkKeywords.some(keyword => 
      errorMessage.toLowerCase().includes(keyword.toLowerCase())
    )
  }

  /**
   * 判断是否为存储错误
   * @param {Error|String} error 错误对象或错误信息
   * @returns {Boolean} 是否为存储错误
   */
  isStorageError(error) {
    const errorMessage = typeof error === 'string' ? error : (error.message || '')
    const storageKeywords = ['storage', '存储', 'disk', '磁盘', 'space', '空间']
    return storageKeywords.some(keyword => 
      errorMessage.toLowerCase().includes(keyword.toLowerCase())
    )
  }

  /**
   * 处理权限错误
   * @param {Object} options 处理选项
   * @returns {Promise} 处理结果
   */
  async handlePermissionError(options = {}) {
    const {
      title = '权限申请',
      content = '需要相关权限才能使用此功能，是否前往设置开启权限？',
      confirmText = '去设置',
      cancelText = '取消',
      onConfirm = null,
      onCancel = null
    } = options

    return new Promise((resolve) => {
      uni.showModal({
        title,
        content,
        confirmText,
        cancelText,
        success: (res) => {
          if (res.confirm) {
            if (onConfirm) {
              onConfirm()
            }
            resolve({ action: 'confirm' })
          } else {
            if (onCancel) {
              onCancel()
            }
            resolve({ action: 'cancel' })
          }
        }
      })
    })
  }

  /**
   * 处理网络错误
   * @param {Object} options 处理选项
   * @returns {Promise} 处理结果
   */
  async handleNetworkError(options = {}) {
    const {
      title = '网络错误',
      content = '网络连接异常，请检查网络设置后重试',
      confirmText = '重试',
      cancelText = '取消',
      onConfirm = null,
      onCancel = null
    } = options

    return new Promise((resolve) => {
      uni.showModal({
        title,
        content,
        confirmText,
        cancelText,
        success: (res) => {
          if (res.confirm) {
            if (onConfirm) {
              onConfirm()
            }
            resolve({ action: 'retry' })
          } else {
            if (onCancel) {
              onCancel()
            }
            resolve({ action: 'cancel' })
          }
        }
      })
    })
  }

  /**
   * 处理存储错误
   * @param {Object} options 处理选项
   * @returns {Promise} 处理结果
   */
  async handleStorageError(options = {}) {
    const {
      title = '存储空间不足',
      content = '设备存储空间不足，请清理空间后重试',
      confirmText = '确定',
      cancelText = '取消',
      onConfirm = null,
      onCancel = null
    } = options

    return new Promise((resolve) => {
      uni.showModal({
        title,
        content,
        confirmText,
        cancelText,
        success: (res) => {
          if (res.confirm) {
            if (onConfirm) {
              onConfirm()
            }
            resolve({ action: 'confirm' })
          } else {
            if (onCancel) {
              onCancel()
            }
            resolve({ action: 'cancel' })
          }
        }
      })
    })
  }

  /**
   * 统一错误处理
   * @param {Error|String} error 错误对象或错误信息
   * @param {Object} options 处理选项
   * @returns {Promise} 处理结果
   */
  async handleError(error, options = {}) {
    const {
      onPermissionError = null,
      onNetworkError = null,
      onStorageError = null,
      onOtherError = null,
      defaultAction = 'toast'
    } = options

    if (this.isPermissionError(error)) {
      if (onPermissionError) {
        return await onPermissionError(error)
      } else {
        return await this.handlePermissionError()
      }
    } else if (this.isNetworkError(error)) {
      if (onNetworkError) {
        return await onNetworkError(error)
      } else {
        return await this.handleNetworkError()
      }
    } else if (this.isStorageError(error)) {
      if (onStorageError) {
        return await onStorageError(error)
      } else {
        return await this.handleStorageError()
      }
    } else {
      if (onOtherError) {
        return await onOtherError(error)
      } else {
        // 默认显示错误提示
        if (defaultAction === 'toast') {
          const errorMessage = typeof error === 'string' ? error : (error.message || '操作失败')
          uni.showToast({
            title: errorMessage,
            icon: 'error'
          })
        }
        return { action: 'default' }
      }
    }
  }

  /**
   * 获取错误类型
   * @param {Error|String} error 错误对象或错误信息
   * @returns {String} 错误类型
   */
  getErrorType(error) {
    if (this.isPermissionError(error)) {
      return 'permission'
    } else if (this.isNetworkError(error)) {
      return 'network'
    } else if (this.isStorageError(error)) {
      return 'storage'
    } else {
      return 'unknown'
    }
  }

  /**
   * 获取友好的错误信息
   * @param {Error|String} error 错误对象或错误信息
   * @returns {String} 友好的错误信息
   */
  getFriendlyErrorMessage(error) {
    const errorType = this.getErrorType(error)
    
    const messages = {
      permission: '需要相关权限才能使用此功能',
      network: '网络连接异常，请检查网络设置',
      storage: '存储空间不足，请清理空间后重试',
      unknown: '操作失败，请稍后重试'
    }
    
    return messages[errorType] || '操作失败'
  }
}

// 创建单例实例
const errorHandler = new ErrorHandler()

export default errorHandler
